OPC Studio User's Guide and Reference
Examples - OPC UA PubSub - Extract a field from the message

.NET

// This example shows how to subscribe to dataset messages and extract data of a specific field.
//
// In order to produce network messages for this example, run the UADemoPublisher tool. For documentation, see
// https://kb.opclabs.com/UADemoPublisher_Basics . In some cases, you may have to specify the interface name to be used.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
// OPC client and subscriber examples in C# on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-CSharp .
// Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
// a commercial license in order to use Online Forums, and we reply to every post.

using System;
using System.Threading;
using OpcLabs.EasyOpc.UA.PubSub;
using OpcLabs.EasyOpc.UA.PubSub.Configuration;
using OpcLabs.EasyOpc.UA.PubSub.OperationModel;

namespace UASubscriberDocExamples.PubSub._EasyUASubscriber
{
    partial class SubscribeDataSet
    {
        public static void ExtractField()
        {
            // Define the PubSub connection we will work with. Uses implicit conversion from a string.
            UAPubSubConnectionDescriptor pubSubConnectionDescriptor = "opc.udp://239.0.0.1";
            // In some cases you may have to set the interface (network adapter) name that needs to be used, similarly to
            // the statement below. Your actual interface name may differ, of course.
            //pubSubConnectionDescriptor.ResourceAddress.InterfaceName = "Ethernet";

            // Define the filter. Publisher Id (unsigned 64-bits) is 31, and the dataset writer Id is 1.
            var filter = new UASubscribeDataSetFilter(UAPublisherId.CreateUInt64(31), UAWriterGroupDescriptor.Null, 1);

            // Define the metadata, with the use of collection initializer for its fields. For UADP, the order of field
            // metadata must correspond to the order of fields in the dataset message. If the field names were contained
            // in the dataset message (such as in JSON), or if we knew the metadata from some other source, this step would
            // not be needed.
            // Since the encoding is not RawData, we do not have to specify the type information for the fields.
            var metaData = new UADataSetMetaData
            {
                new UAFieldMetaData("BoolToggle"),
                new UAFieldMetaData("Int32"),
                new UAFieldMetaData("Int32Fast"),
                new UAFieldMetaData("DateTime")
            };

            // Instantiate the subscriber object and hook events.
            var subscriber = new EasyUASubscriber();
            subscriber.DataSetMessage += subscriber_DataSetMessage_ExtractField;

            Console.WriteLine("Subscribing...");
            subscriber.SubscribeDataSet(pubSubConnectionDescriptor, filter, metaData);

            Console.WriteLine("Processing dataset message events for 20 seconds...");
            Thread.Sleep(20 * 1000);

            Console.WriteLine("Unsubscribing...");
            subscriber.UnsubscribeAllDataSets();

            Console.WriteLine("Waiting for 1 second...");
            // Unsubscribe operation is asynchronous, messages may still come for a short while.
            Thread.Sleep(1 * 1000);

            Console.WriteLine("Finished.");
        }

        static void subscriber_DataSetMessage_ExtractField(object sender, EasyUADataSetMessageEventArgs e)
        {
            // Display the dataset.
            if (e.Succeeded)
            {
                // An event with null DataSetData just indicates a successful connection.
                if (!(e.DataSetData is null))
                {
                    // Extract field data, looking up the field by its name.
                    UADataSetFieldData int32FastValueData = e.DataSetData.FieldDataDictionary["Int32Fast"];
                    Console.WriteLine(int32FastValueData);
                }
            }
            else
            {
                Console.WriteLine($"*** Failure: {e.ErrorMessageBrief}");
            }
        }

        // Example output:
        //
        //Subscribing...
        //Processing dataset message events for 20 seconds...
        //6502 {System.Int32} @2019-10-06T10:02:01.254,647,600,00; Good
        //6538 {System.Int32} @2019-10-06T10:02:01.755,010,700,00; Good
        //6615 {System.Int32} @2019-10-06T10:02:02.255,780,200,00; Good
        //6687 {System.Int32} @2019-10-06T10:02:02.756,495,900,00; Good
        //6769 {System.Int32} @2019-10-06T10:02:03.257,320,200,00; Good
        //6804 {System.Int32} @2019-10-06T10:02:03.757,667,300,00; Good
        //6877 {System.Int32} @2019-10-06T10:02:04.258,405,000,00; Good
        //6990 {System.Int32} @2019-10-06T10:02:04.759,532,900,00; Good
        //7063 {System.Int32} @2019-10-06T10:02:05.260,257,200,00; Good
        //7163 {System.Int32} @2019-10-06T10:02:05.761,261,800,00; Good
        //7255 {System.Int32} @2019-10-06T10:02:06.262,176,800,00; Good
        //7321 {System.Int32} @2019-10-06T10:02:06.762,839,800,00; Good
        //7397 {System.Int32} @2019-10-06T10:02:07.263,598,900,00; Good
        //7454 {System.Int32} @2019-10-06T10:02:07.764,168,900,00; Good
        //7472 {System.Int32} @2019-10-06T10:02:08.264,350,400,00; Good
        //...
    }
}

' This example shows how to subscribe to dataset messages and extract data of a specific field.
'
' In order to produce network messages for this example, run the UADemoPublisher tool. For documentation, see
' https://kb.opclabs.com/UADemoPublisher_Basics . In some cases, you may have to specify the interface name to be used.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
' OPC client and subscriber examples in VB.NET on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBNET .
' Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
' a commercial license in order to use Online Forums, and we reply to every post.

Imports OpcLabs.EasyOpc.UA.PubSub
Imports OpcLabs.EasyOpc.UA.PubSub.Configuration
Imports OpcLabs.EasyOpc.UA.PubSub.OperationModel

Namespace PubSub._EasyUASubscriber
    Partial Friend Class SubscribeDataSet
        Public Shared Sub ExtractField()

            ' Define the PubSub connection we will work with. Uses implicit conversion from a string.
            Dim pubSubConnectionDescriptor As UAPubSubConnectionDescriptor = "opc.udp://239.0.0.1"
            ' In some cases you may have to set the interface (network adapter) name that needs to be used, similarly to
            ' the statement below. Your actual interface name may differ, of course.
            ' pubSubConnectionDescriptor.ResourceAddress.InterfaceName = "Ethernet"

            ' Define the filter. Publisher Id (unsigned 64-bits) is 31, and the dataset writer Id is 1.
            Dim filter = New UASubscribeDataSetFilter(UAPublisherId.CreateUInt64(31), UAWriterGroupDescriptor.Null, 1)

            ' Define the metadata, with the use of collection initializer for its fields. For UADP, the order of field
            ' metadata must correspond to the order of fields in the dataset message. If the field names were contained
            ' in the dataset message (such as in JSON), or if we knew the metadata from some other source, this step would
            ' Not be needed.
            ' Since the encoding is not RawData, we do not have to specify the type information for the fields.
            Dim metaData = New UADataSetMetaData From {
                New UAFieldMetaData("BoolToggle"),
                New UAFieldMetaData("Int32"),
                New UAFieldMetaData("Int32Fast"),
                New UAFieldMetaData("DateTime")
            }

            ' Instantiate the subscriber object and hook events.
            Dim subscriber = New EasyUASubscriber()
            AddHandler subscriber.DataSetMessage, AddressOf subscriber_DataSetMessage_ExtractField

            Console.WriteLine("Subscribing...")
            subscriber.SubscribeDataSet(pubSubConnectionDescriptor, filter, metaData)

            Console.WriteLine("Processing dataset message events for 20 seconds...")
            Threading.Thread.Sleep(20 * 1000)

            Console.WriteLine("Unsubscribing...")
            subscriber.UnsubscribeAllDataSets()

            Console.WriteLine("Waiting for 1 second...")
            ' Unsubscribe operation is asynchronous, messages may still come for a short while.
            Threading.Thread.Sleep(1 * 1000)

            Console.WriteLine("Finished...")
        End Sub

        Private Shared Sub subscriber_DataSetMessage_ExtractField(ByVal sender As Object, ByVal e As EasyUADataSetMessageEventArgs)
            ' Display the dataset.
            If e.Succeeded Then
                ' An event with null DataSetData just indicates a successful connection.
                If e.DataSetData IsNot Nothing Then
                    ' Extract field data, looking up the field by its name.
                    Dim int32FastValueData = e.DataSetData.FieldDataDictionary("Int32Fast")
                    Console.WriteLine(int32FastValueData)
                End If
            Else
                Console.WriteLine($"*** Failure: {e.ErrorMessageBrief}")
            End If
        End Sub
    End Class

    ' Example output
    '
    'Subscribing...
    'Processing dataset message events for 20 seconds...
    '6502 {System.Int32} @2019-10-06T10:02:01.254,647,600,00; Good
    '6538 {System.Int32} @2019-10-06T10:02:01.755,010,700,00; Good
    '6615 {System.Int32} @2019-10-06T10:02:02.255,780,200,00; Good
    '6687 {System.Int32} @2019-10-06T10:02:02.756,495,900,00; Good
    '6769 {System.Int32} @2019-10-06T10:02:03.257,320,200,00; Good
    '6804 {System.Int32} @2019-10-06T10:02:03.757,667,300,00; Good
    '6877 {System.Int32} @2019-10-06T10:02:04.258,405,000,00; Good
    '6990 {System.Int32} @2019-10-06T10:02:04.759,532,900,00; Good
    '7063 {System.Int32} @2019-10-06T10:02:05.260,257,200,00; Good
    '7163 {System.Int32} @2019-10-06T10:02:05.761,261,800,00; Good
    '7255 {System.Int32} @2019-10-06T10:02:06.262,176,800,00; Good
    '7321 {System.Int32} @2019-10-06T10:02:06.762,839,800,00; Good
    '7397 {System.Int32} @2019-10-06T10:02:07.263,598,900,00; Good
    '7454 {System.Int32} @2019-10-06T10:02:07.764,168,900,00; Good
    '7472 {System.Int32} @2019-10-06T10:02:08.264,350,400,00; Good
    '...

End Namespace

COM

// This example shows how to subscribe to dataset messages and extract data of a specific field.
//
// In order to produce network messages for this example, run the UADemoPublisher tool. For documentation, see
// https://kb.opclabs.com/UADemoPublisher_Basics . In some cases, you may have to specify the interface name to be used.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
// OPC client and subscriber examples in Object Pascal (Delphi) on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-OP .
// Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
// a commercial license in order to use Online Forums, and we reply to every post.

type
  TSubscriberEventHandlers74 = class
    procedure OnDataSetMessage(
      ASender: TObject;
      sender: OleVariant;
      const eventArgs: _EasyUADataSetMessageEventArgs);
  end;

class procedure SubscribeDataSet.ExtractField;
var
  ConnectionDescriptor: _UAPubSubConnectionDescriptor;
  Field1, Field2, Field3, Field4: _UAFieldMetaData;
  MetaData: _UADataSetMetaData;
  SubscribeDataSetArguments: _EasyUASubscribeDataSetArguments;
  Subscriber: TEasyUASubscriber;
  SubscriberEventHandlers: TSubscriberEventHandlers74;
begin
  // Define the PubSub connection we will work with.
  SubscribeDataSetArguments := CoEasyUASubscribeDataSetArguments.Create;
  ConnectionDescriptor := SubscribeDataSetArguments.DataSetSubscriptionDescriptor.ConnectionDescriptor;
  ConnectionDescriptor.ResourceAddress.ResourceDescriptor.UrlString := 'opc.udp://239.0.0.1';
  // In some cases you may have to set the interface (network adapter) name that needs to be used, similarly to
  // the statement below. Your actual interface name may differ, of course.
  //ConnectionDescriptor.ResourceAddress.InterfaceName := 'Ethernet';

  // Define the filter. Publisher Id (unsigned 64-bits) is 31, and the dataset writer Id is 1.
  SubscribeDataSetArguments.DataSetSubscriptionDescriptor.Filter.PublisherId.SetIdentifier(UAPublisherIdType_UInt64, 31);
  SubscribeDataSetArguments.DataSetSubscriptionDescriptor.Filter.DataSetWriterDescriptor.DataSetWriterId := 1;

  // Define the metadata. For UADP, the order of field metadata must correspond to the order of fields in the dataset message.
  // If the field names were contained in the dataset message (such as in JSON), or if we knew the metadata from some other
  // source, this step would not be needed.
  // Since the encoding is not RawData, we do not have to specify the type information for the fields.
  MetaData := CoUADataSetMetaData.Create;
  //
  Field1 := CoUAFieldMetaData.Create;
  Field1.Name := 'BoolToggle';
  MetaData.Add(Field1);
  //
  Field2 := CoUAFieldMetaData.Create;
  Field2.Name := 'Int32';
  MetaData.Add(Field2);
  //
  Field3 := CoUAFieldMetaData.Create;
  Field3.Name := 'Int32Fast';
  MetaData.Add(Field3);
  //
  Field4 := CoUAFieldMetaData.Create;
  Field4.Name := 'DateTime';
  MetaData.Add(Field4);
  //
  SubscribeDataSetArguments.DataSetSubscriptionDescriptor.DataSetMetaData := MetaData;

  // Instantiate the subscriber object and hook events.
  Subscriber := TEasyUASubscriber.Create(nil);
  SubscriberEventHandlers := TSubscriberEventHandlers74.Create;
  Subscriber.OnDataSetMessage := SubscriberEventHandlers.OnDataSetMessage;

  WriteLn('Subscribing...');
  Subscriber.SubscribeDataSet(SubscribeDataSetArguments);

  WriteLn('Processing dataset message for 20 seconds...');
  PumpSleep(20*1000);

  WriteLn('Unsubscribing...');
  Subscriber.UnsubscribeAllDataSets;

  WriteLn('Waiting for 1 second...');
  // Unsubscribe operation is asynchronous, messages may still come for a short while.
  PumpSleep(1*1000);

  WriteLn('Finished.');
  FreeAndNil(Subscriber);
  FreeAndNil(SubscriberEventHandlers);
end;

procedure TSubscriberEventHandlers74.OnDataSetMessage(
  ASender: TObject;
  sender: OleVariant;
  const eventArgs: _EasyUADataSetMessageEventArgs);
var
  Dnt32FastValueData: _UADataSetFieldData;
begin
  // Display the dataset.
  if eventArgs.Succeeded then
  begin
    // An event with null DataSetData just indicates a successful connection.
    if eventArgs.DataSetData <> nil then
    begin
      // Extract field data, looking up the field by its name.
      Dnt32FastValueData := eventArgs.DataSetData.FieldDataDictionary.Item['Int32Fast'];
      WriteLn(Dnt32FastValueData.ToString);
    end;
  end
  else begin
    WriteLn;
      WriteLn('*** Failure: ', eventArgs.ErrorMessageBrief);
  end;
end;

// Example output:
//
//Subscribing...
//Processing dataset message events for 20 seconds...
//6502 {System.Int32} @2019-10-06T10:02:01.254,647,600,00; Good
//6538 {System.Int32} @2019-10-06T10:02:01.755,010,700,00; Good
//6615 {System.Int32} @2019-10-06T10:02:02.255,780,200,00; Good
//6687 {System.Int32} @2019-10-06T10:02:02.756,495,900,00; Good
//6769 {System.Int32} @2019-10-06T10:02:03.257,320,200,00; Good
//6804 {System.Int32} @2019-10-06T10:02:03.757,667,300,00; Good
//6877 {System.Int32} @2019-10-06T10:02:04.258,405,000,00; Good
//6990 {System.Int32} @2019-10-06T10:02:04.759,532,900,00; Good
//7063 {System.Int32} @2019-10-06T10:02:05.260,257,200,00; Good
//7163 {System.Int32} @2019-10-06T10:02:05.761,261,800,00; Good
//7255 {System.Int32} @2019-10-06T10:02:06.262,176,800,00; Good
//7321 {System.Int32} @2019-10-06T10:02:06.762,839,800,00; Good
//7397 {System.Int32} @2019-10-06T10:02:07.263,598,900,00; Good
//7454 {System.Int32} @2019-10-06T10:02:07.764,168,900,00; Good
//7472 {System.Int32} @2019-10-06T10:02:08.264,350,400,00; Good
//...

Rem This example shows how to subscribe to dataset messages and extract data of a specific field.
Rem
Rem In order to produce network messages for this example, run the UADemoPublisher tool. For documentation, see
Rem https://kb.opclabs.com/UADemoPublisher_Basics . In some cases, you may have to specify the interface name to be used.
Rem
Rem Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
Rem OPC client and subscriber examples in VBScript on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBScript .
Rem Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
Rem a commercial license in order to use Online Forums, and we reply to every post.

Option Explicit

Const UAPublisherIdType_UInt64 = 4

' Define the PubSub connection we will work with.
Dim SubscribeDataSetArguments: Set SubscribeDataSetArguments = CreateObject("OpcLabs.EasyOpc.UA.PubSub.OperationModel.EasyUASubscribeDataSetArguments")
Dim ConnectionDescriptor: Set ConnectionDescriptor = SubscribeDataSetArguments.DataSetSubscriptionDescriptor.ConnectionDescriptor
ConnectionDescriptor.ResourceAddress.ResourceDescriptor.UrlString = "opc.udp://239.0.0.1"
' In some cases you may have to set the interface (network adapter) name that needs to be used, similarly to
' the statement below. Your actual interface name may differ, of course.
' ConnectionDescriptor.ResourceAddress.InterfaceName = "Ethernet"

' Define the filter. Publisher Id (unsigned 64-bits) is 31, and the dataset writer Id is 1.
SubscribeDataSetArguments.DataSetSubscriptionDescriptor.Filter.PublisherId.SetIdentifier UAPublisherIdType_UInt64, 31
SubscribeDataSetArguments.DataSetSubscriptionDescriptor.Filter.DataSetWriterDescriptor.DataSetWriterId = 1

' Define the metadata. For UADP, the order of field metadata must correspond to the order of fields in the dataset message. 
' If the field names were contained in the dataset message (such as in JSON), or if we knew the metadata from some other 
' source, this step would not be needed.
' Since the encoding is not RawData, we do not have to specify the type information for the fields.
Dim MetaData: Set MetaData = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UADataSetMetaData")
'
Dim Field1: Set Field1 = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UAFieldMetaData")
Field1.Name = "BoolToggle"
MetaData.Add(Field1)
'
Dim Field2: Set Field2 = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UAFieldMetaData")
Field2.Name = "Int32"
MetaData.Add(Field2)
'
Dim Field3: Set Field3 = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UAFieldMetaData")
Field3.Name = "Int32Fast"
MetaData.Add(Field3)
'
Dim Field4: Set Field4 = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UAFieldMetaData")
Field4.Name = "DateTime"
MetaData.Add(Field4)
'
Set SubscribeDataSetArguments.DataSetSubscriptionDescriptor.DataSetMetaData = MetaData

' Instantiate the subscriber object and hook events.
Dim Subscriber: Set Subscriber = CreateObject("OpcLabs.EasyOpc.UA.PubSub.EasyUASubscriber")
WScript.ConnectObject Subscriber, "Subscriber_"

WScript.Echo "Subscribing..."
Subscriber.SubscribeDataSet SubscribeDataSetArguments

WScript.Echo "Processing dataset message events for 20 seconds..."
WScript.Sleep 20*1000

WScript.Echo "Unsubscribing..."
Subscriber.UnsubscribeAllDataSets

WScript.Echo "Waiting for 1 second..."
' Unsubscribe operation is asynchronous, messages may still come for a short while.
WScript.Sleep 1*1000

WScript.Echo "Finished."



Sub Subscriber_DataSetMessage(Sender, e)
    ' Display the dataset.
    If e.Succeeded Then
        ' An event with null DataSetData just indicates a successful connection.
        If Not (e.DataSetData Is Nothing) Then
            ' Extract field data, looking up the field by its name.
            Dim Int32FastValueData: Set Int32FastValueData = e.DataSetData.FieldDataDictionary.Item("Int32Fast")
            WScript.Echo Int32FastValueData
        End If
    Else
        WScript.Echo
        WScript.Echo "*** Failure: " & e.ErrorMessageBrief
    End If
End Sub



' Example output:
'
'Subscribing...
'Processing dataset message events for 20 seconds...
'6502 {System.Int32} @2019-10-06T10:02:01.254,647,600,00; Good
'6538 {System.Int32} @2019-10-06T10:02:01.755,010,700,00; Good
'6615 {System.Int32} @2019-10-06T10:02:02.255,780,200,00; Good
'6687 {System.Int32} @2019-10-06T10:02:02.756,495,900,00; Good
'6769 {System.Int32} @2019-10-06T10:02:03.257,320,200,00; Good
'6804 {System.Int32} @2019-10-06T10:02:03.757,667,300,00; Good
'6877 {System.Int32} @2019-10-06T10:02:04.258,405,000,00; Good
'6990 {System.Int32} @2019-10-06T10:02:04.759,532,900,00; Good
'7063 {System.Int32} @2019-10-06T10:02:05.260,257,200,00; Good
'7163 {System.Int32} @2019-10-06T10:02:05.761,261,800,00; Good
'7255 {System.Int32} @2019-10-06T10:02:06.262,176,800,00; Good
'7321 {System.Int32} @2019-10-06T10:02:06.762,839,800,00; Good
'7397 {System.Int32} @2019-10-06T10:02:07.263,598,900,00; Good
'7454 {System.Int32} @2019-10-06T10:02:07.764,168,900,00; Good
'7472 {System.Int32} @2019-10-06T10:02:08.264,350,400,00; Good
'...


REM This example shows how to subscribe to dataset messages extract data of a specific field.
REM
REM In order to produce network messages for this example, run the UADemoPublisher tool. For documentation, see
REM https://kb.opclabs.com/UADemoPublisher_Basics . In some cases, you may have to specify the interface name to be used.
REM
REM Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
REM OPC client and subscriber examples in Visual Basic on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VB .
REM Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
REM a commercial license in order to use Online Forums, and we reply to every post.

' The subscriber object, with events.
'Public WithEvents Subscriber7 As EasyUASubscriber

Private Sub EasyUASubscriber_SubscribeDataSet_ExtractField_Command_Click()
    OutputText = ""

    Const UAPublisherIdType_UInt64 = 4

    ' Define the PubSub connection we will work with.
    Dim subscribeDataSetArguments :  Set subscribeDataSetArguments = CreateObject("OpcLabs.EasyOpc.UA.PubSub.OperationModel.EasyUASubscribeDataSetArguments")
    Dim ConnectionDescriptor :  Set ConnectionDescriptor = subscribeDataSetArguments.dataSetSubscriptionDescriptor.ConnectionDescriptor
    ConnectionDescriptor.ResourceAddress.ResourceDescriptor.UrlString = "opc.udp://239.0.0.1"
    ' In some cases you may have to set the interface (network adapter) name that needs to be used, similarly to
    ' the statement below. Your actual interface name may differ, of course.
    ' ConnectionDescriptor.ResourceAddress.InterfaceName = "Ethernet"

    ' Define the filter. Publisher Id (unsigned 64-bits) is 31, and the dataset writer Id is 1.
    subscribeDataSetArguments.dataSetSubscriptionDescriptor.Filter.PublisherId.SetIdentifier UAPublisherIdType_UInt64, 31
    subscribeDataSetArguments.dataSetSubscriptionDescriptor.Filter.DataSetWriterDescriptor.DataSetWriterId = 1

    ' Define the metadata. For UADP, the order of field metadata must correspond to the order of fields in the dataset message.
    ' If the field names were contained in the dataset message (such as in JSON), or if we knew the metadata from some other
    ' source, this step would not be needed.
    ' Since the encoding is not RawData, we do not have to specify the type information for the fields.
    Dim metaData :  Set metaData = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UADataSetMetaData")
    '
    Dim field1 :  Set field1 = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UAFieldMetaData")
    field1.Name = "BoolToggle"
    metaData.Add(field1)
    '
    Dim field2 :  Set field2 = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UAFieldMetaData")
    field2.Name = "Int32"
    metaData.Add(field2)
    '
    Dim field3 :  Set field3 = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UAFieldMetaData")
    field3.Name = "Int32Fast"
    metaData.Add(field3)
    '
    Dim field4 :  Set field4 = CreateObject("OpcLabs.EasyOpc.UA.PubSub.Configuration.UAFieldMetaData")
    field4.Name = "DateTime"
    metaData.Add(field4)
    '
    Set subscribeDataSetArguments.dataSetSubscriptionDescriptor.DataSetMetaData = metaData
    
    ' Instantiate the subscriber object and hook events.
    Set Subscriber7 = New EasyUASubscriber

    OutputText = OutputText & "Subscribing..." & vbCrLf
    Subscriber7.SubscribeDataSet subscribeDataSetArguments

    OutputText = OutputText & "Processing dataset message events for 20 seconds..." & vbCrLf
    Pause 20 * 1000

    OutputText = OutputText & "Unsubscribing..." & vbCrLf
    Subscriber7.UnsubscribeAllDataSets

    OutputText = OutputText & "Waiting for 1 second..." & vbCrLf
    ' Unsubscribe operation is asynchronous, messages may still come for a short while.
    Pause 1000

    Set Subscriber7 = Nothing

    OutputText = OutputText & "Finished." & vbCrLf
End Sub

Private Sub Subscriber7_DataSetMessage(ByVal sender As Variant, ByVal eventArgs As EasyUADataSetMessageEventArgs)
    ' Display the dataset.
    If eventArgs.Succeeded Then
        ' An event with null DataSetData just indicates a successful connection.
        If Not (eventArgs.DataSetData Is Nothing) Then
            ' Extract field data, looking up the field by its name.
            Dim Int32FastValueData :  Set Int32FastValueData = eventArgs.DataSetData.FieldDataDictionary.Item("Int32Fast")
            OutputText = OutputText & Int32FastValueData & vbCrLf
        End If
    Else
        OutputText = OutputText & vbCrLf
        OutputText = OutputText & "*** Failure: " & eventArgs.ErrorMessageBrief & vbCrLf
    End If
End Sub
' Example output:
'
'Subscribing...
'Processing dataset message events for 20 seconds...
'6502 {System.Int32} @2019-10-06T10:02:01.254,647,600,00; Good
'6538 {System.Int32} @2019-10-06T10:02:01.755,010,700,00; Good
'6615 {System.Int32} @2019-10-06T10:02:02.255,780,200,00; Good
'6687 {System.Int32} @2019-10-06T10:02:02.756,495,900,00; Good
'6769 {System.Int32} @2019-10-06T10:02:03.257,320,200,00; Good
'6804 {System.Int32} @2019-10-06T10:02:03.757,667,300,00; Good
'6877 {System.Int32} @2019-10-06T10:02:04.258,405,000,00; Good
'6990 {System.Int32} @2019-10-06T10:02:04.759,532,900,00; Good
'7063 {System.Int32} @2019-10-06T10:02:05.260,257,200,00; Good
'7163 {System.Int32} @2019-10-06T10:02:05.761,261,800,00; Good
'7255 {System.Int32} @2019-10-06T10:02:06.262,176,800,00; Good
'7321 {System.Int32} @2019-10-06T10:02:06.762,839,800,00; Good
'7397 {System.Int32} @2019-10-06T10:02:07.263,598,900,00; Good
'7454 {System.Int32} @2019-10-06T10:02:07.764,168,900,00; Good
'7472 {System.Int32} @2019-10-06T10:02:08.264,350,400,00; Good
'...

Python

# This example shows how to subscribe to dataset messages and extract data of a specific field.
#
# In order to produce network messages for this example, run the UADemoPublisher tool. For documentation, see
# https://kb.opclabs.com/UADemoPublisher_Basics . In some cases, you may have to specify the interface name to be used.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
# OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python .
# Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
# a commercial license in order to use Online Forums, and we reply to every post.
# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc
import time

# Import .NET namespaces.
from System import *
from OpcLabs.EasyOpc.UA.PubSub import *
from OpcLabs.EasyOpc.UA.PubSub.Configuration import *
from OpcLabs.EasyOpc.UA.PubSub.OperationModel import *


def dataSetMessage(sender, e):
    # Display the dataset.
    if e.Succeeded:
        # An event with null DataSetData just indicates a successful connection.
        if e.DataSetData is not None:
            # Extract field data, looking up the field by its name.
            int32FastValueData = e.DataSetData.FieldDataDictionary.get_Item('Int32Fast')
            print(int32FastValueData)
    else:
        print('')
        print('*** Failure: ', e.ErrorMessageBrief, sep='')


# Define the PubSub connection we will work with. Uses implicit conversion from a string.
pubSubConnectionDescriptor = UAPubSubConnectionDescriptor.op_Implicit('opc.udp://239.0.0.1')
# In some cases you may have to set the interface (network adapter) name that needs to be used, similarly to
# the statement below. Your actual interface name may differ, of course.
#pubSubConnectionDescriptor.ResourceAddress.InterfaceName = 'Ethernet'

# Define the filter. Publisher Id (unsigned 64-bits) is 31, and the dataset writer Id is 1.
filter = UASubscribeDataSetFilter(UAPublisherId.CreateUInt64(Decimal(31)),
                                  UAWriterGroupDescriptor.Null,
                                  UADataSetWriterDescriptor(1))

# Define the metadata. For UADP, the order of field metadata must correspond to the order of fields in the dataset
# message. If the field names were contained in the dataset message (such as in JSON), or if we knew the metadata from
# some other source, this step would not be needed.
# Since the encoding is not RawData, we do not have to specify the type information for the fields.
metaData = UADataSetMetaData()
metaData.Add(UAFieldMetaData('BoolToggle'))
metaData.Add(UAFieldMetaData('Int32'))
metaData.Add(UAFieldMetaData('Int32Fast'))
metaData.Add(UAFieldMetaData('DateTime'))

# Instantiate the subscriber object and hook events.
subscriber = EasyUASubscriber()
subscriber.DataSetMessage += dataSetMessage

print('Subscribing...')
IEasyUASubscriberExtension.SubscribeDataSet(subscriber, pubSubConnectionDescriptor, filter, metaData)

print('Processing dataset message events for 20 seconds...')
time.sleep(20)

print('Unsubscribing...')
subscriber.UnsubscribeAllDataSets()

print('Waiting for 1 second...')
# Unsubscribe operation is asynchronous, messages may still come for a short while.
time.sleep(1)

subscriber.DataSetMessage -= dataSetMessage

print('Finished.')

 

See Also
Examples - OPC UA PubSub - Subscribe to a single dataset field
Examples - OPC UA PubSub - Specify filter for dataset messages

 

 

Copyright © 2004-2024 CODE Consulting and Development, s.r.o., Plzen. All rights reserved. Web page: www.opclabs.com

Documentation Home, Send Feedback. Resources: Knowledge Base, Product Downloads. Technical support: Online Forums, FAQ.

Missing some example? Ask us for it on our Online Forums! You do not have to own a commercial license in order to use Online Forums, and we reply to every post.